/**
 * 图书状态管理
 * 使用Pinia管理图书数据和推荐信息
 */
import { defineStore } from 'pinia';
import api from '@/api/index.js';

// 定义图书状态store
export const useBookStore = defineStore('book', {
  // 状态数据
  state: () => ({
    // 热门图书列表
    hotBooks: [],
    // 新上架图书列表
    newBooks: [],
    // 推荐图书列表
    recommendBooks: [],
    // 个性化推荐图书列表
    personalRecommendations: [],
    // 分类列表
    categories: [],
    // 当前图书详情
    currentBook: null,
    // 相似图书列表
    similarBooks: [],
    // 加载状态
    loading: {
      hot: false,
      new: false,
      recommend: false,
      personal: false,
      category: false,
      detail: false,
      similar: false
    },
    // 错误信息
    error: null
  }),
  
  // 计算属性
  getters: {
    // 获取分类名称列表
    categoryNames: (state) => state.categories.map(item => item.name)
  },
  
  // 操作方法
  actions: {
    /**
     * 获取热门图书
     * @param {Object} params 查询参数 {page, size}
     * @returns {Promise<Array>} 热门图书列表
     */
    async fetchHotBooks(params = { page: 1, size: 10 }) {
      try {
        this.loading.hot = true;
        console.log('开始获取热门图书 - 时间:', new Date().toLocaleString());
        
        // 添加时间戳参数避免缓存
        params._t = new Date().getTime();
        const res = await api.recommendation.getHotBooks(params);
        console.log('热门图书原始响应:', res);
        
        let booksList = [];
        
        // 处理不同的响应格式
        if (res && res.code === 200 && res.data) {
          console.log('检测到标准ResultVO格式响应');
          
          // 处理data中的数据
          if (Array.isArray(res.data)) {
            booksList = res.data;
            console.log('图书数据是数组格式，长度:', res.data.length);
          } else if (typeof res.data === 'object') {
            // 分页数据格式处理
            if (res.data.content && Array.isArray(res.data.content)) {
              booksList = res.data.content;
              console.log('图书数据是Spring Data分页格式');
            } else if (res.data.list && Array.isArray(res.data.list)) {
              booksList = res.data.list;
              console.log('图书数据是list属性格式');
            } else if (res.data.records && Array.isArray(res.data.records)) {
              booksList = res.data.records;
              console.log('图书数据是records属性格式(MyBatis-Plus)');
            } else {
              // 尝试将data转为数组
              try {
                booksList = Object.values(res.data);
                console.log('将data属性转换为数组');
              } catch (e) {
                console.error('无法转换data为数组:', e);
              }
            }
          }
        } else if (Array.isArray(res)) {
          booksList = res;
          console.log('检测到直接返回数组格式');
        } else if (res && res.data) {
          // 已经排除了res.code===200的情况，现在处理其他情况
          if (Array.isArray(res.data)) {
            booksList = res.data;
          } else if (typeof res.data === 'object') {
            // 尝试从res.data中获取数组
            const possibleArrayProps = ['list', 'content', 'records', 'items'];
            for (const prop of possibleArrayProps) {
              if (res.data[prop] && Array.isArray(res.data[prop])) {
                booksList = res.data[prop];
                console.log(`从${prop}属性中获取图书数组`);
                break;
              }
            }
          }
        }
        
        // 过滤无效数据
        booksList = booksList.filter(item => item != null);
        
        // 打印结果
        console.log('最终解析得到热门图书数量:', booksList.length);
        if (booksList.length > 0) {
          console.log('第一本图书示例:', booksList[0]);
        } else {
          console.warn('未找到有效图书数据!');
        }
        
        // 更新到商店中
        this.hotBooks = booksList;
        return booksList;
      } catch (error) {
        this.error = error.message || '获取热门图书失败';
        console.error('获取热门图书失败:', error);
        // 返回空数组避免前端报错
        return [];
      } finally {
        this.loading.hot = false;
      }
    },
    
    /**
     * 获取分类下的热门图书
     * @param {String|Number} categoryId 分类ID
     * @param {Object} params 查询参数 {page, size}
     * @returns {Promise<Array>} 热门图书列表
     */
    async fetchHotBooksByCategory(categoryId, params = { page: 1, size: 10 }) {
      try {
        this.loading.hot = true;
        
        const res = await api.recommendation.getHotBooksByCategory(categoryId, params);
        
        if (res && res.data) {
          return res.data.list || [];
        } else {
          throw new Error('获取分类热门图书失败');
        }
      } catch (error) {
        this.error = error.message || '获取分类热门图书失败';
        console.error('获取分类热门图书失败:', error);
        // 返回空数组避免前端报错
        return [];
      } finally {
        this.loading.hot = false;
      }
    },
    
    /**
     * 获取新上架图书
     * @param {Object} params 查询参数 {page, size}
     * @returns {Promise<Array>} 新上架图书列表
     */
    async fetchNewBooks(params = { page: 1, size: 10 }) {
      try {
        this.loading.new = true;
        console.log('开始获取新上架图书 - 时间:', new Date().toLocaleString());
        
        // 添加时间戳参数避免缓存
        params._t = new Date().getTime();
        const res = await api.recommendation.getNewBooks(params);
        console.log('新上架图书原始响应:', res);
        
        let booksList = [];
        
        // 处理不同的响应格式
        if (res && res.code === 200 && res.data) {
          console.log('检测到标准ResultVO格式响应');
          
          // 处理data中的数据
          if (Array.isArray(res.data)) {
            booksList = res.data;
            console.log('图书数据是数组格式，长度:', res.data.length);
          } else if (typeof res.data === 'object') {
            // 分页数据格式处理
            if (res.data.content && Array.isArray(res.data.content)) {
              booksList = res.data.content;
              console.log('图书数据是Spring Data分页格式');
            } else if (res.data.list && Array.isArray(res.data.list)) {
              booksList = res.data.list;
              console.log('图书数据是list属性格式');
            } else if (res.data.records && Array.isArray(res.data.records)) {
              booksList = res.data.records;
              console.log('图书数据是records属性格式(MyBatis-Plus)');
            } else {
              // 尝试将data转为数组
              try {
                booksList = Object.values(res.data);
                console.log('将data属性转换为数组');
              } catch (e) {
                console.error('无法转换data为数组:', e);
              }
            }
          }
        } else if (Array.isArray(res)) {
          booksList = res;
          console.log('检测到直接返回数组格式');
        } else if (res && res.data) {
          // 已经排除了res.code===200的情况，现在处理其他情况
          if (Array.isArray(res.data)) {
            booksList = res.data;
          } else if (typeof res.data === 'object') {
            // 尝试从res.data中获取数组
            const possibleArrayProps = ['list', 'content', 'records', 'items'];
            for (const prop of possibleArrayProps) {
              if (res.data[prop] && Array.isArray(res.data[prop])) {
                booksList = res.data[prop];
                console.log(`从${prop}属性中获取图书数组`);
                break;
              }
            }
          }
        }
        
        // 过滤无效数据
        booksList = booksList.filter(item => item != null);
        
        // 打印结果
        console.log('最终解析得到新上架图书数量:', booksList.length);
        if (booksList.length > 0) {
          console.log('第一本新上架图书示例:', booksList[0]);
        } else {
          console.warn('未找到新上架图书数据!');
        }
        
        // 更新到商店中
        this.newBooks = booksList;
        return booksList;
      } catch (error) {
        this.error = error.message || '获取新上架图书失败';
        console.error('获取新上架图书失败:', error);
        // 返回空数组避免前端报错
        return [];
      } finally {
        this.loading.new = false;
      }
    },
    
    /**
     * 获取分类下的新上架图书
     * @param {String|Number} categoryId 分类ID
     * @param {Object} params 查询参数 {page, size}
     * @returns {Promise<Array>} 新上架图书列表
     */
    async fetchNewBooksByCategory(categoryId, params = { page: 1, size: 10 }) {
      try {
        this.loading.new = true;
        
        const res = await api.recommendation.getNewBooksByCategory(categoryId, params);
        
        if (res && res.data) {
          return res.data.list || [];
        } else {
          throw new Error('获取分类新上架图书失败');
        }
      } catch (error) {
        this.error = error.message || '获取分类新上架图书失败';
        console.error('获取分类新上架图书失败:', error);
        // 返回空数组避免前端报错
        return [];
      } finally {
        this.loading.new = false;
      }
    },
    
    /**
     * 获取个性化推荐
     * @param {Number|String} userId 用户ID
     * @param {Object} params 查询参数 {page, size}
     * @returns {Promise<Array>} 推荐图书列表
     */
    async fetchPersonalRecommendations(userId, params = { page: 1, size: 10 }) {
      try {
        this.loading.personal = true;
        
        // 验证用户ID是否有效
        if (!userId || userId === 'null' || userId === 'undefined') {
          console.log('用户ID无效，不请求个性化推荐');
          this.personalRecommendations = [];
          return [];
        }
        
        // 尝试将用户ID转为数字
        const numericUserId = parseInt(userId);
        if (isNaN(numericUserId) || numericUserId <= 0) {
          console.log('用户ID不是有效的数字，不请求个性化推荐');
          this.personalRecommendations = [];
          return [];
        }
        
        // 使用有效的数字ID请求个性化推荐
        const res = await api.recommendation.getPersonalRecommendations(numericUserId, params);
        
        if (res && res.data) {
          this.personalRecommendations = res.data.list || [];
          return res.data.list || [];
        } else {
          throw new Error('获取个性化推荐失败');
        }
      } catch (error) {
        this.error = error.message || '获取个性化推荐失败';
        console.error('获取个性化推荐失败:', error);
        // 个性化推荐失败时返回空数组
        this.personalRecommendations = [];
        return [];
      } finally {
        this.loading.personal = false;
      }
    },
    
    /**
     * 获取相似图书
     * @param {Number} bookId 图书ID
     * @param {Object} params 查询参数 {page, size}
     * @returns {Promise<Array>} 相似图书列表
     */
    async fetchSimilarBooks(bookId, params = { page: 1, size: 10 }) {
      try {
        this.loading.similar = true;
        
        const res = await api.recommendation.getSimilarBooks(bookId, params);
        
        if (res && res.data) {
          this.similarBooks = res.data.list || [];
          return res.data.list || [];
        } else {
          throw new Error('获取相似图书失败');
        }
      } catch (error) {
        this.error = error.message || '获取相似图书失败';
        console.error('获取相似图书失败:', error);
        // 返回空数组避免前端报错
        return [];
      } finally {
        this.loading.similar = false;
      }
    },
    
    /**
     * 获取作者其他作品
     * @param {Number} authorId 作者ID
     * @param {Object} params 查询参数 {page, size}
     * @returns {Promise<Array>} 作者其他作品列表
     */
    async fetchAuthorOtherBooks(authorId, params = { page: 1, size: 10 }) {
      try {
        const res = await api.recommendation.getAuthorOtherBooks(authorId, params);
        
        if (res && res.data) {
          return res.data.list || [];
        } else {
          throw new Error('获取作者其他作品失败');
        }
      } catch (error) {
        console.error('获取作者其他作品失败:', error);
        // 返回空数组避免前端报错
        return [];
      }
    },
    
    /**
     * 获取图书详情
     * @param {Number} bookId 图书ID
     * @returns {Promise<Object>} 图书详情
     */
    async fetchBookDetail(bookId) {
      try {
        this.loading.detail = true;
        
        const res = await api.book.getBookDetail(bookId);
        
        if (res && res.data) {
          this.currentBook = res.data;
          return res.data;
        } else {
          throw new Error('获取图书详情失败');
        }
      } catch (error) {
        this.error = error.message || '获取图书详情失败';
        console.error('获取图书详情失败:', error);
        return null;
      } finally {
        this.loading.detail = false;
      }
    },
    
    /**
     * 获取所有分类
     * @returns {Promise<Array>} 分类列表
     */
    async fetchCategories() {
      try {
        this.loading.category = true;
        // 清除旧数据，避免变更未反映
        this.categories = [];
        
        console.log('开始获取分类数据 - 时间:', new Date().toLocaleString());
        
        // 添加时间戳参数避免缓存
        const timestamp = new Date().getTime();
        const res = await api.category.getAllCategories({ _t: timestamp });
        console.log('后端返回分类原始数据:', res);
        
        // 检查响应状态
        if (!res) {
          console.error('响应为空！');
          throw new Error('请求返回空响应');
        }
        
        let categoriesList = [];
        
        // 判断哪些属性里包含数据
        console.log('响应可用属性:', Object.keys(res));
        
        // 1. 先检查Spring Boot ResultVO的标准格式
        if (res.code === 200 && res.data) {
          console.log('检测到 ResultVO 格式响应');
          
          // 处理 data 中的数据
          if (Array.isArray(res.data)) {
            categoriesList = res.data;
            console.log('分类数据是数组格式，长度:', res.data.length);
          } else if (typeof res.data === 'object') {
            // 检查各种可能的嵌套格式
            if (res.data.list && Array.isArray(res.data.list)) {
              categoriesList = res.data.list;
              console.log('分类数据是 list 属性格式，长度:', res.data.list.length);
            } else if (res.data.content && Array.isArray(res.data.content)) {
              categoriesList = res.data.content;
              console.log('分类数据是 Spring Data 分页格式，长度:', res.data.content.length);
            } else {
              // 如果 data 是对象但没有已知属性，尝试将其转换为数组
              try {
                categoriesList = Object.values(res.data);
                console.log('将 data 属性转换为数组，长度:', categoriesList.length);
              } catch (e) {
                console.error('无法将 data 转换为数组:', e);
              }
            }
          }
        } 
        // 2. 如果不是标准格式，检查响应根属性
        else if (res.data) {
          // 与上面相同的处理逻辑，但已经在最外层检查res.data
          if (Array.isArray(res.data)) {
            categoriesList = res.data;
          } else {
            try {
              categoriesList = Object.values(res.data);
            } catch (e) {
              console.error('无法处理未知格式的数据:', res.data);
            }
          }
        } 
        // 3. 检查是否直接返回数组
        else if (Array.isArray(res)) {
          console.log('检测到直接返回的数组格式');
          categoriesList = res;
        } 
        // 4. 检查是否是Response对象(针对uni-app的特殊处理)
        else if (res.statusCode === 200 && res.data) {
          console.log('检测到 uni-app Response 格式');
          // 递归处理res.data
          return this.processResponseData(res.data);
        } 
        // 5. 假设整个响应对象就是分类数据
        else {
          try {
            categoriesList = Object.values(res);
            console.log('尝试将整个响应转换为数组，长度:', categoriesList.length);
          } catch (e) {
            console.error('无法将整个响应转换为数组:', e);
          }
        }
        
        // 去除可能的null及undefined项
        categoriesList = categoriesList.filter(item => item != null);
        
        // 确认数据结构，必须至少有id和name属性
        const validCategories = categoriesList.filter(item => 
          item && typeof item === 'object' && item.id && item.name
        );
        
        if (validCategories.length !== categoriesList.length) {
          console.warn(`过滤了${categoriesList.length - validCategories.length}条无效分类数据`);
          categoriesList = validCategories;
        }
        
        // 打印最终结果
        console.log('最终解析得到分类数量:', categoriesList.length);
        if (categoriesList.length > 0) {
          console.log('第一个分类示例:', categoriesList[0]);
        } else {
          console.warn('未找到有效分类数据!');
        }
        
        // 更新到商店中
        this.categories = categoriesList;
        return categoriesList;
        
      } catch (error) {
        this.error = error.message || '获取分类列表失败';
        console.error('获取分类列表失败:', error);
        
        // 返回空数组避免前端报错
        this.categories = [];
        return [];
      } finally {
        this.loading.category = false;
      }
    },
    
    /**
     * 处理响应数据的辅助方法
     * @param {any} data 需要处理的数据
     * @returns {Array} 解析后的分类数组
     */
    processResponseData(data) {
      if (!data) return [];
      
      if (Array.isArray(data)) {
        return data;
      }
      
      if (data.list && Array.isArray(data.list)) {
        return data.list;
      }
      
      if (data.content && Array.isArray(data.content)) {
        return data.content;
      }
      
      if (data.data) {
        return this.processResponseData(data.data);
      }
      
      try {
        const values = Object.values(data);
        // 检查是否有效
        if (values.length > 0 && typeof values[0] === 'object') {
          return values;
        }
      } catch (e) {
        console.error('无法将数据转换为数组:', e);
      }
      
      return [];
    },
    
    /**
     * 获取分类详情
     * @param {Number} categoryId 分类ID
     * @returns {Promise<Object>} 分类详情
     */
    async fetchCategoryDetail(categoryId) {
      try {
        const res = await api.category.getCategoryDetail(categoryId);
        
        if (res && res.data) {
          return res.data;
        } else {
          throw new Error('获取分类详情失败');
        }
      } catch (error) {
        this.error = error.message || '获取分类详情失败';
        console.error('获取分类详情失败:', error);
        return null;
      }
    },
    
    /**
     * 获取分类下的图书
     * @param {Number} categoryId 分类ID
     * @param {Object} params 查询参数 {page, size, sort, order}
     * @returns {Promise<Array>} 图书列表
     */
    async fetchCategoryBooks(categoryId, params = { page: 1, size: 10 }) {
      try {
        const res = await api.category.getCategoryBooks(categoryId, params);
        
        if (res && res.data) {
          return res.data.list || [];
        } else {
          throw new Error('获取分类图书失败');
        }
      } catch (error) {
        this.error = error.message || '获取分类图书失败';
        console.error('获取分类图书失败:', error);
        // 返回空数组避免前端报错
        return [];
      }
    },
    
    /**
     * 搜索图书
     * @param {Object} params 搜索参数 {keyword, page, size, sort, order, categoryId}
     * @returns {Promise<Array>} 搜索结果
     */
    async searchBooks(params = { keyword: '', page: 1, size: 10 }) {
      try {
        const res = await api.book.searchBooks(params);
        
        if (res && res.data) {
          return res.data;
        } else {
          throw new Error('搜索图书失败');
        }
      } catch (error) {
        console.error('搜索图书失败:', error);
        // 返回空结果对象避免前端报错
        return { list: [], total: 0 };
      }
    }
  }
});
